home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt32s2.arc / PIBANSIB.PAS next >
Encoding:
Pascal/Delphi Source File  |  1985-11-15  |  54.6 KB  |  1,483 lines
  1. (*----------------------------------------------------------------------*)
  2. (*             Ansi_Set_Graphics --- Set graphics display               *)
  3. (*----------------------------------------------------------------------*)
  4.   
  5. PROCEDURE Ansi_Set_Graphics;
  6.   
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure: Ansi_Set_Graphics                                     *)
  10. (*                                                                      *)
  11. (*     Purpose:   Sets graphics rendition modes for ANSI/VT100          *) 
  12. (*                                                                      *)
  13. (*     Calling Sequence:                                                *)
  14. (*                                                                      *)
  15. (*        Ansi_Set_Graphics;                                            *)
  16. (*                                                                      *)
  17. (*     Calls:                                                           *) 
  18. (*                                                                      *)
  19. (*        TextColor                                                     *)
  20. (*        TextBackGround                                                *)
  21. (*                                                                      *)
  22. (*     Called by:  VT100_Process_Escape                                 *)
  23. (*                 Ansi_Process_Escape                                  *)
  24. (*                                                                      *)
  25. (*----------------------------------------------------------------------*)
  26.  
  27. VAR
  28.    I     : INTEGER;
  29.    J     : INTEGER;
  30.  
  31. BEGIN (* Ansi_Set_Graphics *)
  32.  
  33.    IF ( Escape_Number = 0 ) THEN
  34.       BEGIN
  35.          Escape_Number      := 1;
  36.          Escape_Register[1] := 0;
  37.       END;
  38.  
  39.    FOR I := 1 TO Escape_Number DO
  40.       BEGIN
  41.  
  42.          CASE Escape_Register[I] OF
  43.  
  44.             0 : BEGIN
  45.                    IF VT100_Allowed THEN
  46.                       FG := Ansi_ForeGround_Color
  47.                    ELSE
  48.                       FG := Normal_Colors[ FG ];
  49.                    BG          := Ansi_BackGround_Color;
  50.                    Bolding_On  := FALSE;
  51.                    Blinking_On := FALSE;
  52.                 END;
  53.  
  54.             1 : BEGIN
  55.                    IF VT100_Allowed THEN
  56.                       FG          := Ansi_Bold_Color
  57.                    ELSE
  58.                       FG          := Bold_Colors[ FG ];
  59.                    Bolding_On  := TRUE;
  60.                 END;
  61.  
  62.             4 : BEGIN
  63.                                    (* NOTE: In mono mode BLUE will    *)
  64.                                    (* correctly produce an underline. *)
  65.  
  66.                    FG := Ansi_Underline_Color;
  67.  
  68.                 END;
  69.  
  70.             5 : Blinking_On := TRUE;
  71.  
  72.             7 : BEGIN
  73.                    FG := Ansi_BackGround_Color;
  74.                    BG := Ansi_ForeGround_Color;
  75.                 END;
  76.  
  77.             8 : FG := BG;
  78.  
  79.            30 : IF Bolding_On THEN
  80.                    FG := DarkGray
  81.                 ELSE
  82.                    FG := Black;
  83.  
  84.            31 : IF ( Text_Mode = C80 ) THEN
  85.                    IF Bolding_On THEN
  86.                       FG := LightRed
  87.                    ELSE
  88.                       FG := Red;
  89.  
  90.            32 : IF ( Text_Mode = C80 ) THEN
  91.                    IF Bolding_On THEN
  92.                       FG := LightGreen
  93.                    ELSE
  94.                       FG := Green;
  95.  
  96.            33 : IF ( Text_Mode = C80 ) THEN
  97.                    IF Bolding_On THEN
  98.                       FG := Yellow
  99.                    ELSE
  100.                       FG := Brown;
  101.  
  102.            34 : IF ( Text_Mode = C80 ) THEN
  103.                    IF Bolding_On THEN
  104.                       FG := LightBlue
  105.                    ELSE
  106.                       FG := Blue;
  107.  
  108.            35 : IF ( Text_Mode = C80 ) THEN
  109.                    IF Bolding_On THEN
  110.                       FG := LightMagenta
  111.                    ELSE
  112.                       FG := Magenta;
  113.  
  114.            36 : IF ( Text_Mode = C80 ) THEN
  115.                    IF Bolding_On THEN
  116.                       FG := LightCyan
  117.                    ELSE
  118.                       FG := Cyan;
  119.  
  120.            37 : IF ( Text_Mode = C80 ) THEN
  121.                    IF Bolding_On THEN
  122.                       FG := White
  123.                    ELSE
  124.                       FG := LightGray;
  125.  
  126.            40 : IF Bolding_On THEN
  127.                    BG := DarkGray
  128.                 ELSE
  129.                    BG := Black;
  130.  
  131.            41 : IF ( Text_Mode = C80 ) THEN
  132.                    IF Bolding_On THEN
  133.                       BG := LightRed
  134.                    ELSE
  135.                       BG := Red;
  136.  
  137.            42 : IF ( Text_Mode = C80 ) THEN
  138.                    IF Bolding_On THEN
  139.                       BG := LightGreen
  140.                    ELSE
  141.                       BG := Green;
  142.  
  143.            43 : IF ( Text_Mode = C80 ) THEN
  144.                    IF Bolding_On THEN
  145.                       BG := Yellow
  146.                    ELSE
  147.                       BG := Brown;
  148.  
  149.            44 : IF ( Text_Mode = C80 ) THEN
  150.                    IF Bolding_On THEN
  151.                       BG := LightBlue
  152.                    ELSE
  153.                       BG := Blue;
  154.  
  155.            45 : IF ( Text_Mode = C80 ) THEN
  156.                    IF Bolding_On THEN
  157.                       BG := LightMagenta
  158.                    ELSE
  159.                       BG := Magenta;
  160.  
  161.            46 : IF ( Text_Mode = C80 ) THEN
  162.                    IF Bolding_On THEN
  163.                       BG := LightCyan
  164.                    ELSE
  165.                       BG := Cyan;
  166.  
  167.            47 : IF ( Text_Mode = C80 ) THEN
  168.                    IF Bolding_On THEN
  169.                       BG := White
  170.                    ELSE
  171.                       BG := LightGray;
  172.  
  173.          END (* CASE *);
  174.  
  175.       END;
  176.                                    (* Change the colors *)
  177.    IF Blinking_On THEN
  178.       TextColor( FG + Blink )
  179.    ELSE
  180.       TextColor( FG );
  181.  
  182.    TextBackGround( BG );
  183.  
  184. END   (* Ansi_Set_Graphics *);
  185.  
  186. (*----------------------------------------------------------------------*)
  187. (*             Ansi_Set_Cursor --- Set cursor position                  *)
  188. (*----------------------------------------------------------------------*)
  189.  
  190. PROCEDURE Ansi_Set_Cursor;
  191.   
  192. (*----------------------------------------------------------------------*)
  193. (*                                                                      *)
  194. (*     Procedure: Ansi_Set_Cursor                                       *)
  195. (*                                                                      *)
  196. (*     Purpose:   Sets cursor position                                  *)
  197. (*                                                                      *)
  198. (*     Calling Sequence:                                                *)
  199. (*                                                                      *)
  200. (*        Ansi_Set_Cursor;                                              *)
  201. (*                                                                      *)
  202. (*     Calls:                                                           *) 
  203. (*                                                                      *)
  204. (*        Max                                                           *)
  205. (*        Min                                                           *)
  206. (*        UpperLeft                                                     *)
  207. (*                                                                      *)
  208. (*     Called by:  VT100_Process_Escape                                 *)
  209. (*                 Ansi_Process_Escape                                  *)
  210. (*                                                                      *)
  211. (*----------------------------------------------------------------------*)
  212.   
  213. VAR
  214.    Row:     INTEGER;
  215.    Col:     INTEGER;
  216.   
  217. BEGIN (* Ansi_Set_Cursor *)
  218.   
  219.    CASE Escape_Number OF
  220.                                    (* Home cursor if no coords given *)
  221.       0 : BEGIN
  222.              Row := 1;
  223.              Col := 1;
  224.           END;
  225.                                    (* Column 1 is default, row provided *) 
  226.       1 : BEGIN
  227.              Col := 1;
  228.              Row := Escape_Register[1];
  229.           END;
  230.                                    (* Both row and column provided *)
  231.       ELSE
  232.              Col := Escape_Register[2];
  233.              Row := Escape_Register[1];
  234.   
  235.    END;
  236.   
  237.    Row := MAX( MIN( Row , 25 ) , 1 );
  238.    Col := MAX( MIN( Col , 80 ) , 1 );
  239.   
  240.                                    (* Move to new coordinates *)
  241.    GoToXY( Col , Row ); 
  242.   
  243. END   (* Ansi_Set_Cursor *);
  244.   
  245. (*----------------------------------------------------------------------*)
  246. (*             Ansi_Clear_Screen --- Clear segment of screen            *)
  247. (*----------------------------------------------------------------------*)
  248.   
  249. PROCEDURE Ansi_Clear_Screen;
  250.   
  251. (*----------------------------------------------------------------------*)
  252. (*                                                                      *)
  253. (*     Procedure: Ansi_Clear_Screen                                     *)
  254. (*                                                                      *)
  255. (*     Purpose:   Clears portion of screen                              *)
  256. (*                                                                      *)
  257. (*     Calling Sequence:                                                *)
  258. (*                                                                      *)
  259. (*        Ansi_Clear_Screen;                                            *)
  260. (*                                                                      *)
  261. (*     Called by:  VT100_Process_Escape                                 *)
  262. (*                 Ansi_Process_Escape                                  *)
  263. (*                                                                      *)
  264. (*----------------------------------------------------------------------*)
  265.   
  266. VAR
  267.    I:        INTEGER;
  268.    X:        INTEGER;
  269.    Y:        INTEGER;
  270.    C:        INTEGER;
  271.    Save_FG1: INTEGER;
  272.    Save_BG1: INTEGER;
  273.   
  274. BEGIN (* Ansi_Clear_Screen *)
  275.   
  276.    IF ( Escape_Number = 1 )  THEN
  277.       C := Escape_Register[1]
  278.    ELSE
  279.       C := 0;
  280.   
  281.    Save_FG1 := FG;
  282.    Save_BG1 := BG;
  283.   
  284.    TextColor     ( Ansi_ForeGround_Color );
  285.    TextBackGround( Ansi_BackGround_Color ); 
  286.   
  287.    CASE C OF
  288.                                    (* Clear from cursor position to *)
  289.                                    (* end of screen                 *)
  290.       0:  BEGIN
  291.   
  292.              X := WhereX;
  293.              Y := WhereY;
  294.   
  295.              ClrEol;
  296.   
  297.              FOR I := ( Y + 1 ) TO 25 DO
  298.                 BEGIN
  299.                    GoToXY( 1 , I );
  300.                    ClrEol;
  301.                 END;
  302.   
  303.              GoToXY( X , Y );
  304.   
  305.           END;
  306.                                    (* Clear start of screen to current *) 
  307.                                    (* cursor position                  *)
  308.       1:  BEGIN
  309.   
  310.              X     := WhereX;
  311.              Y     := WhereY;
  312.   
  313.              FOR I := 1 TO ( Y - 1 ) DO
  314.                 DelLine; 
  315.  
  316.              FOR I := 1 TO X DO
  317.                 WRITE(' ');
  318.   
  319.           END;
  320.                                    (* Clear entire screen *)
  321.       2:  ClrScr;
  322.  
  323.    END (* CASE *);
  324.   
  325.    TextColor     ( Save_FG1 );
  326.    TextBackGround( Save_BG1 );
  327.   
  328. END   (* Ansi_Clear_Screen *);
  329.   
  330. (*----------------------------------------------------------------------*)
  331. (*             Ansi_Clear_Line --- Clear part of line in display        *)
  332. (*----------------------------------------------------------------------*)
  333.   
  334. PROCEDURE Ansi_Clear_Line;
  335.   
  336. (*----------------------------------------------------------------------*)
  337. (*                                                                      *)
  338. (*     Procedure: Ansi_Clear_Line                                       *)
  339. (*                                                                      *)
  340. (*     Purpose:   Clears portion of current line                        *)
  341. (*                                                                      *)
  342. (*     Calling Sequence:                                                *)
  343. (*                                                                      *)
  344. (*        Ansi_Clear_Line;                                              *)
  345. (*                                                                      *)
  346. (*     Called by:  VT100_Process_Escape                                 *)
  347. (*                 Ansi_Process_Escape                                  *)
  348. (*                                                                      *)
  349. (*----------------------------------------------------------------------*)
  350.   
  351. VAR
  352.    I:        INTEGER;
  353.    X:        INTEGER;
  354.    Y:        INTEGER;
  355.    C:        INTEGER;
  356.    Save_FG1: INTEGER;
  357.    Save_BG1: INTEGER;
  358.   
  359. BEGIN (* Ansi_Clear_Line *)
  360.   
  361.    IF ( Escape_Number = 1 )  THEN
  362.       C := Escape_Register[1]
  363.    ELSE
  364.       C := 0;
  365.   
  366.    Save_FG1 := FG;
  367.    Save_BG1 := BG;
  368.  
  369.    TextColor     ( Ansi_ForeGround_Color );
  370.    TextBackGround( Ansi_BackGround_Color ); 
  371.   
  372.    CASE C OF
  373.                                    (* Clear cursor to end *)
  374.       0:  ClrEol;
  375.                                    (* Clear start to cursor *) 
  376.       1:  BEGIN
  377.              X := WhereX;
  378.              Y := WhereY;
  379.              GoToXY( 1 , Y );
  380.              FOR I := 1 TO X DO
  381.                 WRITE(' ');
  382.           END;
  383.                                    (* Clear entire line *)
  384.       2:  BEGIN
  385.              Y := WhereY;
  386.              GoToXY( 1 , Y );
  387.              ClrEol;
  388.           END;
  389.   
  390.    END  (* CASE *); 
  391.  
  392.    TextColor     ( Save_FG1 );
  393.    TextBackGround( Save_BG1 );
  394.   
  395. END   (* Ansi_Clear_Line *);
  396.   
  397. (*----------------------------------------------------------------------*)
  398. (*          Ansi_Write_Escape --- Write out escape sequence to display  *)
  399. (*----------------------------------------------------------------------*)
  400.   
  401. PROCEDURE Ansi_Write_Escape;
  402.   
  403. (*----------------------------------------------------------------------*)
  404. (*                                                                      *)
  405. (*     Procedure: Ansi_Write_Escape                                     *)
  406. (*                                                                      *)
  407. (*     Purpose:   Writes unused escape sequence chars to display        *)
  408. (*                                                                      *)
  409. (*     Calling Sequence:                                                *)
  410. (*                                                                      *)
  411. (*        Ansi_Write_Escape;                                            *)
  412. (*                                                                      *)
  413. (*     Called by:  VT100_Process_Escape                                 *)
  414. (*                 Ansi_Process_Escape                                  *)
  415. (*                                                                      *)
  416. (*----------------------------------------------------------------------*)
  417.   
  418. VAR
  419.    I: INTEGER;
  420.   
  421. BEGIN (* Ansi_Write_Escape *)
  422.   
  423.    FOR I := 1 TO LENGTH( Escape_Str ) DO
  424.       Display_Character( Escape_Str[I] );
  425.   
  426.    Escape_Type    := ' ';
  427.   
  428. END   (* Ansi_Write_Escape *);
  429.   
  430. (*----------------------------------------------------------------------*)
  431. (*            Ansi_Next_Char --- Get next character in escape sequence  *)
  432. (*----------------------------------------------------------------------*)
  433.   
  434. FUNCTION Ansi_Next_Char : CHAR;
  435.   
  436. (*----------------------------------------------------------------------*)
  437. (*                                                                      *)
  438. (*     Function: Ansi_Next_Char                                         *)
  439. (*                                                                      *)
  440. (*     Purpose:  Waits for next character in escape sequence            *)
  441. (*                                                                      *)
  442. (*     Calling Sequence:                                                *)
  443. (*                                                                      *)
  444. (*        Ansi_Next_Char;                                               *)
  445. (*                                                                      *)
  446. (*     Called by:  VT100_Process_Escape                                 *)
  447. (*                 Ansi_Process_Escape                                  *)
  448. (*                                                                      *)
  449. (*     Remarks:                                                         *)
  450. (*                                                                      *)
  451. (*        This routine actually shouldn't be used, but I got lazy.      *)
  452. (*        Needs to be fixed next time around.                           *)
  453. (*                                                                      *)
  454. (*----------------------------------------------------------------------*)
  455.   
  456. VAR
  457.    Next_Ch: INTEGER;
  458.   
  459. BEGIN (* Ansi_Next_Char *)
  460.  
  461.    Async_Receive_With_Timeout( 1 , Next_Ch );
  462.   
  463.    IF Next_Ch > 0 THEN
  464.       Ansi_Next_Char := CHR( Next_Ch )
  465.    ELSE
  466.       Ansi_Next_Char := CHR( 0 );
  467.   
  468. END   (* Ansi_Next_Char *);
  469.   
  470. (*----------------------------------------------------------------------*)
  471. (*      Ansi_Set_Scrolling_Region --- Set scrolling region (window)     *)
  472. (*----------------------------------------------------------------------*)
  473.   
  474. PROCEDURE Ansi_Set_Scrolling_Region;
  475.   
  476. (*----------------------------------------------------------------------*)
  477. (*                                                                      *)
  478. (*     Procedure: Ansi_Set_Scrolling_Region                             *)
  479. (*                                                                      *)
  480. (*     Purpose:   Sets scrolling region (window)                        *)
  481. (*                                                                      *)
  482. (*     Calling Sequence:                                                *)
  483. (*                                                                      *)
  484. (*        Ansi_Set_Scrolling_Region;                                    *)
  485. (*                                                                      *)
  486. (*     Called by:  VT100_Process_Escape                                 *)
  487. (*                 Ansi_Process_Escape                                  *)
  488. (*                                                                      *)
  489. (*----------------------------------------------------------------------*)
  490.   
  491. VAR
  492.    Top:    INTEGER;
  493.    Bottom: INTEGER;
  494.   
  495. BEGIN (* Ansi_Set_Scrolling_Region *)
  496.   
  497.    CASE Escape_Number OF
  498.                                    (* Window is entire screen *)
  499.       0:  BEGIN
  500.              Top    := 1;
  501.              Bottom := 25;
  502.           END;
  503.                                    (* From specified line to end of screen *)
  504.       1:  BEGIN
  505.              Top    := MAX( Escape_Register[1] , 1 );
  506.              Bottom := 25;
  507.           END;
  508.                                    (* Both top and bottom specified *)
  509.       2:  BEGIN
  510.              Top    := MAX( Escape_Register[1] , 1  ); 
  511.              Bottom := MIN( Escape_Register[2] , 25 );
  512.           END;
  513.   
  514.       ELSE
  515.              Top    := MAX( Escape_Register[1] , 1  ); 
  516.              Bottom := MIN( Escape_Register[2] , 25 );
  517.   
  518.    END (* CASE *);
  519.   
  520.    IF Bottom < Top THEN Bottom := 25;
  521.   
  522.    IF Origin_Mode THEN
  523.       Window( 1, Top, 80, Bottom );
  524.   
  525.    GoToXY( 1 , 1 );
  526.   
  527.    Top_Scroll    := Top;
  528.    Bottom_Scroll := Bottom;
  529.  
  530. END   (* Ansi_Set_Scrolling_Region *);
  531.   
  532. (*----------------------------------------------------------------------*)
  533. (*                    Ansi_Cursor_Up --- Move cursor up                 *)
  534. (*----------------------------------------------------------------------*)
  535.   
  536. PROCEDURE Ansi_Cursor_Up;
  537.   
  538. (*----------------------------------------------------------------------*)
  539. (*                                                                      *)
  540. (*     Procedure: Ansi_Cursor_Up;                                       *)
  541. (*                                                                      *)
  542. (*     Purpose:   Moves cursor up specified number of lines             *)
  543. (*                                                                      *)
  544. (*     Calling Sequence:                                                *)
  545. (*                                                                      *)
  546. (*        Ansi_Cursor_Up;                                               *)
  547. (*                                                                      *)
  548. (*     Called by:  VT100_Process_Escape                                 *)
  549. (*                                                                      *)
  550. (*----------------------------------------------------------------------*)
  551.   
  552. BEGIN (* Ansi_Cursor_Up *)
  553.  
  554.    IF Escape_Number = 0 THEN
  555.       Reg_Val := 1
  556.    ELSE
  557.       Reg_Val := MAX( 1 , Escape_Register[1] );
  558.   
  559.    GoToXY( Wherex, MAX( WhereY - Reg_Val , 1 ) );
  560.   
  561. END   (* Ansi_Cursor_Up *);
  562.   
  563. (*----------------------------------------------------------------------*)
  564. (*                 Ansi_Cursor_Down --- Move cursor down                *)
  565. (*----------------------------------------------------------------------*)
  566.   
  567. PROCEDURE Ansi_Cursor_Down;
  568.   
  569. (*----------------------------------------------------------------------*)
  570. (*                                                                      *)
  571. (*     Procedure: Ansi_Cursor_Down;                                     *)
  572. (*                                                                      *)
  573. (*     Purpose:   Moves cursor down specified number of lines           *)
  574. (*                                                                      *)
  575. (*     Calling Sequence:                                                *)
  576. (*                                                                      *)
  577. (*        Ansi_Cursor_Down;                                             *)
  578. (*                                                                      *)
  579. (*     Called by:  VT100_Process_Escape                                 *)
  580. (*                                                                      *)
  581. (*----------------------------------------------------------------------*)
  582.   
  583. BEGIN (* Ansi_Cursor_Down *) 
  584.   
  585.    IF Escape_Number = 0 THEN
  586.       Reg_Val := 1
  587.    ELSE
  588.       Reg_Val := MAX( 1 , Escape_Register[1] );
  589.   
  590.    GoToXY( Wherex, MIN( WhereY + Reg_Val , 25 ) );
  591.   
  592. END   (* Ansi_Cursor_Down *);
  593.   
  594. (*----------------------------------------------------------------------*)
  595. (*                  Ansi_Cursor_Left --- Move cursor left               *)
  596. (*----------------------------------------------------------------------*)
  597.   
  598. PROCEDURE Ansi_Cursor_Left;
  599.  
  600. (*----------------------------------------------------------------------*)
  601. (*                                                                      *)
  602. (*     Procedure: Ansi_Cursor_Left;                                     *)
  603. (*                                                                      *)
  604. (*     Purpose:   Moves cursor left specified number of columns         *) 
  605. (*                                                                      *)
  606. (*     Calling Sequence:                                                *)
  607. (*                                                                      *)
  608. (*        Ansi_Cursor_Left;                                             *)
  609. (*                                                                      *)
  610. (*     Called by:  VT100_Process_Escape                                 *)
  611. (*                                                                      *)
  612. (*----------------------------------------------------------------------*)
  613.   
  614. BEGIN (* Ansi_Cursor_Left *) 
  615.   
  616.    IF Escape_Number = 0 THEN
  617.       Reg_Val := 1
  618.    ELSE
  619.       Reg_Val := MAX( 1 , Escape_Register[1] );
  620.   
  621.    GoToXY( MAX( Wherex - Reg_Val , 1 ), WhereY );
  622.  
  623. END   (* Ansi_Cursor_Left *);
  624.   
  625. (*----------------------------------------------------------------------*)
  626. (*                 Ansi_Cursor_Right --- Move cursor right              *)
  627. (*----------------------------------------------------------------------*)
  628.   
  629. PROCEDURE Ansi_Cursor_Right;
  630.   
  631. (*----------------------------------------------------------------------*)
  632. (*                                                                      *)
  633. (*     Procedure: Ansi_Cursor_Right;                                    *)
  634. (*                                                                      *)
  635. (*     Purpose:   Moves cursor right specified number of columns        *)
  636. (*                                                                      *)
  637. (*     Calling Sequence:                                                *)
  638. (*                                                                      *)
  639. (*        Ansi_Cursor_Right;                                            *)
  640. (*                                                                      *)
  641. (*     Called by:  VT100_Process_Escape                                 *)
  642. (*                                                                      *)
  643. (*----------------------------------------------------------------------*)
  644.  
  645. BEGIN (* Ansi_Cursor_Right *)
  646.   
  647.    IF Escape_Number = 0 THEN
  648.       Reg_Val := 1
  649.    ELSE
  650.       Reg_Val := MAX( 1 , Escape_Register[1] );
  651.   
  652.    GoToXY( MIN( WhereX + Reg_Val , 80 ), WhereY );
  653.   
  654. END   (* Ansi_Cursor_Right *);
  655.   
  656. (*----------------------------------------------------------------------*)
  657. (*              Ansi_Status_Report --- Provide terminal status          *)
  658. (*----------------------------------------------------------------------*)
  659.   
  660. PROCEDURE Ansi_Status_Report;
  661.   
  662. (*----------------------------------------------------------------------*)
  663. (*                                                                      *)
  664. (*     Procedure: Ansi_Status_Report;                                   *)
  665. (*                                                                      *)
  666. (*     Purpose:   Provides status reports to host enquiries             *)
  667. (*                                                                      *)
  668. (*     Calling Sequence:                                                *)
  669. (*                                                                      *)
  670. (*        Ansi_Status_Report;                                           *)
  671. (*                                                                      *)
  672. (*     Called by:  VT100_Process_Escape                                 *)
  673. (*                                                                      *)
  674. (*----------------------------------------------------------------------*)
  675.   
  676. VAR
  677.    Istatus  : INTEGER; 
  678.    C_Column : STRING[10];
  679.    C_Row    : STRING[10];
  680.   
  681. BEGIN (* Ansi_Status_Report *)
  682.   
  683.    IF Escape_Number = 0 THEN
  684.       Istatus := 5
  685.    ELSE
  686.       Istatus := Escape_Register[ 1 ];
  687.   
  688.    CASE Istatus OF
  689.   
  690.       5:    Async_Send_String( CHR( 27 ) + '[0n' );
  691.  
  692.       6:    BEGIN
  693.                STR( WhereX:3, C_Column );
  694.                STR( WhereY:2, C_Row    );
  695.                Async_Send_String( CHR( 27 ) + '[' +
  696.                                   C_Row + ';' + C_Column + 'R' );
  697.             END;
  698.   
  699.       ELSE;
  700.   
  701.    END   (* CASE *);
  702.   
  703. END   (* Ansi_Status_Report *);
  704.   
  705. (*----------------------------------------------------------------------*)
  706. (*              Ansi_Set_Mode --- Set a terminal mode                   *)
  707. (*----------------------------------------------------------------------*)
  708.   
  709. PROCEDURE Ansi_Set_Mode;
  710.   
  711. (*----------------------------------------------------------------------*)
  712. (*                                                                      *)
  713. (*     Procedure: Ansi_Set_Mode;                                        *)
  714. (*                                                                      *)
  715. (*     Purpose:   Set a terminal mode                                   *)
  716. (*                                                                      *)
  717. (*     Calling Sequence:                                                *)
  718. (*                                                                      *)
  719. (*        Ansi_Set_Mode;                                                *)
  720. (*                                                                      *)
  721. (*     Called by:  VT100_Process_Escape                                 *)
  722. (*                                                                      *)
  723. (*----------------------------------------------------------------------*)
  724.   
  725. VAR
  726.    I: INTEGER;
  727.   
  728. BEGIN (* Ansi_Set_Mode *)
  729.   
  730.    FOR I := 1 TO Escape_Number DO
  731.   
  732.       CASE Escape_Register[I] OF
  733.   
  734.          6:    BEGIN
  735.                   Origin_Mode := ON;
  736.                   Window( 1, Top_Scroll, 80, Bottom_Scroll );
  737.                END;
  738.   
  739.          7:    Auto_Wrap_Mode := ON;
  740.   
  741.          12:   Local_Echo     := ON;
  742.   
  743.          ELSE;
  744.   
  745.       END   (* CASE *);
  746.   
  747. END   (* Ansi_Set_Mode *);
  748.   
  749. (*----------------------------------------------------------------------*)
  750. (*            Ansi_Reset_Mode --- Set a terminal mode                   *) 
  751. (*----------------------------------------------------------------------*)
  752.   
  753. PROCEDURE Ansi_Reset_Mode;
  754.   
  755. (*----------------------------------------------------------------------*)
  756. (*                                                                      *)
  757. (*     Procedure: Ansi_Reset_Mode;                                      *)
  758. (*                                                                      *)
  759. (*     Purpose:   Resets a terminal mode                                *)
  760. (*                                                                      *)
  761. (*     Calling Sequence:                                                *)
  762. (*                                                                      *)
  763. (*        Ansi_Reset_Mode;                                              *)
  764. (*                                                                      *)
  765. (*     Called by:  VT100_Process_Escape                                 *)
  766. (*                                                                      *)
  767. (*----------------------------------------------------------------------*)
  768.   
  769. VAR
  770.    I: INTEGER;
  771.   
  772. BEGIN (* Ansi_Reset_Mode *)
  773.   
  774.    FOR I := 1 TO Escape_Number DO
  775.   
  776.       CASE Escape_Register[I] OF
  777.   
  778.          6:    BEGIN
  779.                   Origin_Mode := OFF;
  780.                   Window( 1, 1, 80, 25 );
  781.                END; 
  782.  
  783.          7:    Auto_Wrap_Mode := OFF;
  784.   
  785.          12:   Local_Echo     := OFF;
  786.   
  787.          ELSE;
  788.   
  789.       END   (* CASE *);
  790.   
  791. END   (* Ansi_Reset_Mode *);
  792.   
  793. (*----------------------------------------------------------------------*)
  794. (*         Ansi_Printer_Control --- Sets printer control modes          *)
  795. (*----------------------------------------------------------------------*)
  796.   
  797. PROCEDURE Ansi_Printer_Control;
  798.   
  799. (*----------------------------------------------------------------------*)
  800. (*                                                                      *)
  801. (*     Procedure: Ansi_Printer_Control;                                 *)
  802. (*                                                                      *)
  803. (*     Purpose:   Sets printer control modes                            *)
  804. (*                                                                      *)
  805. (*     Calling Sequence:                                                *)
  806. (*                                                                      *)
  807. (*        Ansi_Printer_Control;                                         *) 
  808. (*                                                                      *)
  809. (*     Called by:  VT100_Process_Escape                                 *)
  810. (*                                                                      *)
  811. (*----------------------------------------------------------------------*)
  812.   
  813. VAR
  814.    I: INTEGER;
  815.   
  816. BEGIN (* Ansi_Printer_Control *)
  817.  
  818.    IF Escape_Number > 0 THEN
  819.   
  820.       CASE Escape_Register[1] OF
  821.          4: Auto_Print_Mode := OFF;
  822.          5: Auto_Print_Mode := ON;
  823.       END (* CASE *);
  824.   
  825. END   (* Ansi_Printer_Control *);
  826.   
  827. (*----------------------------------------------------------------------*)
  828. (*            Ansi_Process_Escape --- Process ANSI escape sequence      *)
  829. (*----------------------------------------------------------------------*)
  830.   
  831. PROCEDURE Ansi_Process_Escape( Ch : CHAR ); 
  832.   
  833. (*----------------------------------------------------------------------*)
  834. (*                                                                      *)
  835. (*     Procedure: Ansi_Process_Escape                                   *)
  836. (*                                                                      *)
  837. (*     Purpose:   Processes escape sequence for BBS/ANSI emulation      *)
  838. (*                                                                      *)
  839. (*     Calling Sequence:                                                *)
  840. (*                                                                      *)
  841. (*        Ansi_Process_Escape( Ch: CHAR );                              *)
  842. (*                                                                      *)
  843. (*           Ch --- Next character in escape sequence                   *)
  844. (*                                                                      *)
  845. (*     Called by:  Emulate_Ansi                                         *)
  846. (*                                                                      *)
  847. (*     Remarks:                                                         *)
  848. (*                                                                      *)
  849. (*        This version doesn't process private DEC escape sequences,    *) 
  850. (*        but DOES play music.                                          *)
  851. (*                                                                      *)
  852. (*----------------------------------------------------------------------*)
  853.   
  854. VAR
  855.    Reg_Val     : INTEGER;
  856.    Save_X      : INTEGER; 
  857.    Save_Y      : INTEGER; 
  858.    More_Escape : BOOLEAN;
  859.   
  860. BEGIN (* Ansi_Process_Escape *)
  861.   
  862.    More_Escape := FALSE;
  863.  
  864.    CASE Ch OF
  865.   
  866.       ' ' : EXIT;
  867.       ^M  : EXIT; 
  868.       ^J  : EXIT; 
  869.   
  870.       '[' : BEGIN
  871.                Escape_Type    := '[';
  872.                EXIT;
  873.             END;
  874.  
  875.       'f' : Ansi_Set_Cursor;
  876.   
  877.       'H' : Ansi_Set_Cursor; 
  878.   
  879.       'J' : Ansi_Clear_Screen;
  880.   
  881.       'K' : Ansi_Clear_Line; 
  882.   
  883.       'm' : Ansi_Set_Graphics;
  884.   
  885.       ^N  : IF ( Play_Music_On ) THEN
  886.                PibPlay( Escape_Str );
  887.   
  888.       ELSE  More_Escape := TRUE;
  889.   
  890.    END  (* CASE *); 
  891.   
  892.    IF ( NOT More_Escape ) THEN
  893.       Escape_Mode := FALSE
  894.    ELSE
  895.       BEGIN
  896.   
  897.          Ch         := UpCase( Ch );
  898.          Escape_Str := Escape_Str + Ch;
  899.   
  900.          IF Ch IN [ 'A'..'G','L'..'P' ] THEN EXIT;
  901.   
  902.          IF Ch IN [ '0'..'9' ] THEN
  903.             BEGIN
  904.                Escape_Register[Escape_Number] :=
  905.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  906.                                                             ORD( '0' );
  907.                EXIT;
  908.             END;
  909.  
  910.          CASE Ch OF
  911.   
  912.             ';', ',' : BEGIN 
  913.                           Escape_Number                  := Escape_Number + 1; 
  914.                           Escape_Register[Escape_Number] := 0;
  915.                        END;
  916.   
  917.             'T', 'S', '#', '+', '-', '>', '<', '.'
  918.                         : ;
  919.             ELSE
  920.                Escape_Mode := FALSE;
  921.                Ansi_Write_Escape;
  922.   
  923.          END  (* CASE *);
  924.   
  925.    END (* NOT More_Escape *);
  926.   
  927. END   (* Ansi_Process_Escape *);
  928.   
  929. (*----------------------------------------------------------------------*)
  930. (*         VT100_Process_Escape --- Process VT100 escape sequence       *)
  931. (*----------------------------------------------------------------------*)
  932.  
  933. PROCEDURE VT100_Process_Escape( Ch : CHAR );
  934.   
  935. (*----------------------------------------------------------------------*)
  936. (*                                                                      *)
  937. (*     Procedure: VT100_Process_Escape                                  *)
  938. (*                                                                      *)
  939. (*     Purpose:   Processes escape sequence for DEC VT100 emulation     *)
  940. (*                                                                      *)
  941. (*     Calling Sequence:                                                *)
  942. (*                                                                      *)
  943. (*        VT100_Process_Escape( Ch: CHAR );                             *)
  944. (*                                                                      *)
  945. (*           Ch --- Next character in escape sequence                   *)
  946. (*                                                                      *)
  947. (*     Called by:  Emulate_Ansi                                         *)
  948. (*                                                                      *)
  949. (*     Remarks:                                                         *)
  950. (*                                                                      *)
  951. (*        This version processes private DEC escape sequences.          *)
  952. (*                                                                      *)
  953. (*----------------------------------------------------------------------*)
  954.   
  955. VAR
  956.    Reg_Val     : INTEGER;
  957.    Save_X      : INTEGER; 
  958.    Save_Y      : INTEGER; 
  959.    More_Escape : BOOLEAN;
  960.   
  961. BEGIN (* VT100_Process_Escape *)
  962.   
  963.    More_Escape := FALSE;
  964.   
  965.    CASE Ch OF
  966.  
  967.       ' ' : EXIT;
  968.   
  969.       '#' : IF Escape_Type = ' ' THEN
  970.                BEGIN
  971.                   Escape_Type := '#';
  972.                   EXIT;
  973.                END
  974.             ELSE
  975.                More_Escape := TRUE;
  976.   
  977.       '[' : BEGIN
  978.                Escape_Type    := '[';
  979.                EXIT;
  980.             END;
  981.   
  982.       'f' : Ansi_Set_Cursor;
  983.   
  984.       'H' : Ansi_Set_Cursor; 
  985.   
  986.       'J' : Ansi_Clear_Screen;
  987.   
  988.       'K' : Ansi_Clear_Line; 
  989.  
  990.       'g' : ClrScr;
  991.  
  992.       'h' : Ansi_Set_Mode;
  993.  
  994.       'i' : Ansi_Printer_Control;
  995.  
  996.       'l' : Ansi_Reset_Mode;
  997.  
  998.       'm' : Ansi_Set_Graphics;
  999.  
  1000.       'q' : ;
  1001.  
  1002.       'r' : IF ( Escape_Type = '[' ) THEN
  1003.                Ansi_Set_Scrolling_Region; 
  1004.   
  1005.       'c' : Async_Send_String( CHR( 27 ) + '[?1;0c' ); 
  1006.   
  1007.       'Z' : IF ( Escape_Type = ' ' ) THEN
  1008.                Async_Send_String( CHR( 27 ) + '[?1;0c' );
  1009.   
  1010.       'n' : Ansi_Status_Report;
  1011.   
  1012.       '=' : IF ( Escape_Type = ' ' ) THEN
  1013.                VT100_Keypad := ON;
  1014.  
  1015.       '<' : IF ( Escape_Type <> '[' ) THEN
  1016.                BEGIN
  1017.                   Escape_Mode := FALSE;
  1018.                   EXIT;
  1019.                END; 
  1020.   
  1021.       '>' : IF ( Escape_Type = ' ' ) THEN
  1022.                VT100_Keypad := OFF;
  1023.  
  1024.       'A' : CASE Escape_Type OF
  1025.                ' ': More_Escape := TRUE;
  1026.                '[': Ansi_Cursor_Up;
  1027.                ELSE;
  1028.             END (* CASE *);
  1029.   
  1030.       'B' : CASE Escape_Type OF
  1031.                ' ': More_Escape := TRUE;
  1032.                '[': Ansi_Cursor_Down; 
  1033.                ELSE;
  1034.             END (* CASE *);
  1035.   
  1036.       'C' : CASE Escape_Type OF
  1037.                ' ': More_Escape := TRUE;
  1038.                '[': Ansi_Cursor_Right;
  1039.                ELSE;
  1040.             END (* CASE *);
  1041.   
  1042.       'D' : CASE Escape_Type OF
  1043.   
  1044.                ' ': BEGIN
  1045.                        IF WhereY < 25 THEN
  1046.                           GoToXY( WhereX , WhereY + 1 )
  1047.                        ELSE
  1048.                           BEGIN
  1049.                              Save_X := WhereX;
  1050.                              Save_Y := WhereY;
  1051.                              InsLine;
  1052.                              GoToXY( Save_X, Save_Y );
  1053.                           END;
  1054.                     END;
  1055.   
  1056.                '[': Ansi_Cursor_Left; 
  1057.   
  1058.                ELSE;
  1059.   
  1060.             END (* CASE *);
  1061.   
  1062.       '3' : IF Escape_Type <> '#' THEN More_Escape := TRUE;
  1063.   
  1064.       '4' : IF Escape_Type <> '#' THEN More_Escape := TRUE;
  1065.   
  1066.       '5' : IF Escape_Type = '#' THEN
  1067.                Double_Width_Mode := OFF
  1068.             ELSE
  1069.                More_Escape := TRUE;
  1070.  
  1071.       '6' : IF Escape_Type = '#' THEN
  1072.                Double_Width_Mode := ON
  1073.             ELSE
  1074.                More_Escape := TRUE;
  1075.   
  1076.       '7' : CASE Escape_Type OF
  1077.   
  1078.                ' ': BEGIN
  1079.                        Save_Row_Position  := WhereX; 
  1080.                        Save_Col_Position  := WhereY; 
  1081.                        Save_FG_Color      := FG;
  1082.                        Save_BG_Color      := BG;
  1083.                        Save_Graphics_Mode := VT100_Graphics_Mode;
  1084.                     END;
  1085.                 ELSE More_Escape := TRUE;
  1086.   
  1087.             END (* CASE *);
  1088.   
  1089.       '8' : CASE Escape_Type OF
  1090.   
  1091.                ' ': BEGIN
  1092.                        GoToXY( Save_Row_Position , Save_Col_Position );
  1093.                        FG := Save_FG_Color;
  1094.                        BG := Save_BG_Color;
  1095.                        VT100_Graphics_Mode := Save_Graphics_Mode; 
  1096.                        TextColor( FG );
  1097.                        TextBackGround( BG );
  1098.                     END;
  1099.   
  1100.                ELSE More_Escape := TRUE; 
  1101.   
  1102.             END (* CASE *);
  1103.   
  1104.       ')' : IF ( Escape_Type <> '[' ) THEN
  1105.                BEGIN
  1106.                   VT100_Graphics_Mode := FALSE;
  1107.                   Ch := Ansi_Next_Char;
  1108.                END; 
  1109.   
  1110.       '(' : IF ( Escape_Type <> '[' ) THEN
  1111.                BEGIN
  1112.                   Escape_Type := '(';
  1113.                   Ch := Ansi_Next_Char;
  1114.                   VT100_Graphics_Mode := ( Ch = '0' ) AND VT100_Allowed;
  1115.                END;
  1116.  
  1117.       'E' : IF ( Escape_Type <> '[' ) THEN
  1118.                IF ( WhereY >= Top_Scroll    ) AND
  1119.                   ( WhereY <= Bottom_Scroll ) THEN
  1120.                   BEGIN
  1121.                      Window( 1, Top_Scroll, 80, Bottom_Scroll );
  1122.                      WRITELN; 
  1123.                      IF ( NOT Origin_Mode ) THEN
  1124.                         Window( 1, 1, 80, 25 );
  1125.                   END
  1126.                ELSE 
  1127.                   WRITELN;
  1128.   
  1129.       'M' : IF ( Escape_Type <> '[' ) THEN
  1130.                BEGIN
  1131.                   IF WhereY > Top_Scroll THEN
  1132.                      GoToXY( WhereX , WhereY - 1 )
  1133.                   ELSE
  1134.                      BEGIN
  1135.                         Save_X := WhereX; 
  1136.                         Save_Y := WhereY; 
  1137.                         Window( 1, Top_Scroll, 80, Bottom_Scroll ); 
  1138.                         InsLine;
  1139.                         IF ( NOT Origin_Mode ) THEN
  1140.                            Window( 1, 1, 80, 25 );
  1141.                         GoToXY( Save_X, Save_Y );
  1142.                      END;
  1143.                END; 
  1144.   
  1145.       ELSE   More_Escape := TRUE;
  1146.   
  1147.    END  (* CASE *); 
  1148.   
  1149.    IF ( NOT More_Escape ) THEN
  1150.       Escape_Mode := FALSE
  1151.    ELSE
  1152.       BEGIN
  1153.   
  1154.          Ch         := UpCase( Ch );
  1155.          Escape_Str := Escape_Str + Ch;
  1156.   
  1157.          IF Ch IN [ 'A'..'G','L'..'P' ] THEN EXIT;
  1158.   
  1159.          IF Ch IN [ '0'..'9' ] THEN
  1160.             BEGIN
  1161.                Escape_Register[Escape_Number] :=
  1162.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  1163.                                                             ORD( '0' );
  1164.                EXIT;
  1165.             END;
  1166.   
  1167.          CASE Ch OF
  1168.   
  1169.             ';', ',' : BEGIN 
  1170.                           Escape_Number                  := Escape_Number + 1; 
  1171.                           Escape_Register[Escape_Number] := 0;
  1172.                        END;
  1173.   
  1174.             'T', 'S', '#', '+', '-', '>', '<', '.','?','='
  1175.                         : ;
  1176.             ELSE
  1177.                Escape_Mode := FALSE;
  1178.                Ansi_Write_Escape;
  1179.   
  1180.          END  (* Case *);
  1181.   
  1182.       END (* NOT More_Escape *);
  1183.   
  1184. END   (* VT100_Process_Escape *);
  1185.   
  1186. (*----------------------------------------------------------------------*)
  1187. (*       Ansi_Set_Input_Keys --- Set input key mapping for ANSI mode    *)
  1188. (*----------------------------------------------------------------------*)
  1189.   
  1190. PROCEDURE Ansi_Set_Input_Keys;
  1191.   
  1192. (*----------------------------------------------------------------------*)
  1193. (*                                                                      *)
  1194. (*     Procedure: Ansi_Set_Input_Keys                                   *)
  1195. (*                                                                      *)
  1196. (*     Purpose:   Provides conversion string from PC keys to VT100      *)
  1197. (*                                                                      *)
  1198. (*     Calling Sequence:                                                *)
  1199. (*                                                                      *)
  1200. (*        Ansi_Set_Input_Keys;                                          *)
  1201. (*                                                                      *)
  1202. (*     Calls:                                                           *) 
  1203. (*                                                                      *)
  1204. (*        None                                                          *)
  1205. (*                                                                      *)
  1206. (*     Called by:  Emulate_Ansi                                         *)
  1207. (*                                                                      *)
  1208. (*     Remarks:                                                         *)
  1209. (*                                                                      *)
  1210. (*        This routine defines the strings to be sent to the host when  *)
  1211. (*        a keyboard key is depressed.                                  *)
  1212. (*                                                                      *)
  1213. (*----------------------------------------------------------------------*)
  1214.   
  1215. CONST
  1216.    Esc_Char = ^[;
  1217.   
  1218. VAR
  1219.    I: INTEGER;
  1220.    J: INTEGER;
  1221.  
  1222. BEGIN (* Ansi_Set_Input_Keys *)
  1223.                                    (* Make sure the arrows at least are set *)
  1224.   
  1225.    J := Keypad_Key_Index[U_Arrow];
  1226.    I := ( J - 1 ) DIV 10 + 1;
  1227.    J := J - ( I - 1 ) * 10;
  1228.   
  1229.    IF Keypad_Keys[I,J] = '' THEN
  1230.       Keypad_Keys[I,J] := Esc_Char + '[A';
  1231.   
  1232.    J := Keypad_Key_Index[D_Arrow];
  1233.    I := ( J - 1 ) DIV 10 + 1;
  1234.    J := J - ( I - 1 ) * 10;
  1235.   
  1236.    IF Keypad_Keys[I,J] = '' THEN
  1237.       Keypad_Keys[I,J] := Esc_Char + '[B';
  1238.   
  1239.    J := Keypad_Key_Index[L_Arrow];
  1240.    I := ( J - 1 ) DIV 10 + 1;
  1241.    J := J - ( I - 1 ) * 10;
  1242.   
  1243.    IF Keypad_Keys[I,J] = '' THEN
  1244.       Keypad_Keys[I,J] := Esc_Char + '[D';
  1245.   
  1246.    J := Keypad_Key_Index[R_Arrow];
  1247.    I := ( J - 1 ) DIV 10 + 1;
  1248.    J := J - ( I - 1 ) * 10;
  1249.   
  1250.    IF Keypad_Keys[I,J] = '' THEN
  1251.       Keypad_Keys[I,J] := Esc_Char + '[C';
  1252.   
  1253. END   (* Ansi_Set_Input_Keys *);
  1254.   
  1255. (*----------------------------------------------------------------------*)
  1256.   
  1257. BEGIN (* Emulate_ANSI *)
  1258.                                    (* Indicate ANSI/VT100 being simulated *)
  1259.    Save_Screen( Saved_Screen );
  1260.    Draw_Menu_Frame( 10, 10, 55, 15, Menu_Frame_Color,
  1261.                     Menu_Text_Color, '' );
  1262.   
  1263.    IF VT100_Allowed THEN
  1264.       WRITELN('Emulating VT100 Terminal')
  1265.    ELSE
  1266.       WRITELN('Emulating BBS/ANSI Terminal');
  1267.  
  1268.    DELAY( One_Second_Delay );
  1269.   
  1270.    Restore_Screen( Saved_Screen );
  1271.    Reset_Global_Colors;
  1272.   
  1273.                                    (* Initialize terminal state     *)
  1274.    Done                  := FALSE;
  1275.    VT100_Keypad          := OFF;
  1276.    VT100_Graphics_Mode   := OFF;
  1277.    Auto_Print_Mode       := OFF;
  1278.    Origin_Mode           := OFF;
  1279.    Auto_Wrap_Mode        := ON;
  1280.    Printer_Ctrl_Mode     := OFF;
  1281.    Escape_Mode           := FALSE;
  1282.    Escape_Str            := ''; 
  1283.    NewX                  := WhereX;
  1284.    NewY                  := WhereY;
  1285.   
  1286.                                    (* Initial scrolling region is *)
  1287.                                    (* entire screen.              *)
  1288.    Top_Scroll            := 1;
  1289.    Bottom_Scroll         := 24;
  1290.                                    (* Background, foreground      *)
  1291.   
  1292.    Save_Global_FG        := Global_ForeGround_Color;
  1293.    Save_Global_BG        := Global_BackGround_Color;
  1294.    Save_FG               := ForeGround_Color;
  1295.    Save_BG               := BackGround_Color;
  1296.   
  1297.                                    (* Set colors.                *)
  1298.   
  1299.    Ansi_ForeGround_Color := VT100_ForeGround_Color;
  1300.    Ansi_BackGround_Color := VT100_BackGround_Color;
  1301.    Ansi_Underline_Color  := VT100_Underline_Color;
  1302.    Ansi_Bold_Color       := VT100_Bold_Color;
  1303.  
  1304.    ForeGround_Color      := VT100_ForeGround_Color;
  1305.    BackGround_Color      := VT100_BackGround_Color;
  1306.  
  1307.    FG                    := VT100_ForeGround_Color;
  1308.    BG                    := VT100_BackGround_Color;
  1309.  
  1310.    Bolding_On            := FALSE;
  1311.    Blinking_On           := FALSE;
  1312.  
  1313.    Set_Global_Colors( Ansi_ForeGround_Color , Ansi_BackGround_Color );
  1314.  
  1315.                                    (* Initialize music playing   *)
  1316.    PibPlaySet;
  1317.                                    (* Set up input key mapping   *)
  1318.    Ansi_Set_Input_Keys;
  1319.                                    (* Loop over input until done *)
  1320.    WHILE ( NOT Done ) DO
  1321.       BEGIN
  1322.  
  1323.          IF KeyPressed THEN
  1324.             BEGIN (* KeyPressed *)
  1325.   
  1326.                READ( Kbd , Comm_Ch );
  1327.   
  1328.                CASE ORD( Comm_Ch ) OF
  1329.   
  1330.                   ESC:  IF KeyPressed THEN
  1331.                            BEGIN
  1332.                               Process_Command( Comm_Ch, FALSE, PibTerm_Command );
  1333.                               IF PibTerm_Command <> Null_Command THEN 
  1334.                                  Execute_Command( PibTerm_Command, Done, FALSE );
  1335.                            END
  1336.                         ELSE
  1337.                            BEGIN
  1338.                               IF Local_Echo THEN WRITE( Comm_Ch );
  1339.                               Async_Send( Comm_Ch );
  1340.                            END;
  1341.   
  1342.                   BS:   BEGIN
  1343.                            Comm_Ch := BS_Char;
  1344.                            IF Local_Echo THEN WRITE( Comm_Ch );
  1345.                            Async_Send( Comm_Ch );
  1346.                         END;
  1347.   
  1348.                   DEL:  BEGIN
  1349.                            Comm_Ch := Ctrl_BS_Char;
  1350.                            IF Local_Echo THEN WRITE( Comm_Ch );
  1351.                            Async_Send( Comm_Ch );
  1352.                         END;
  1353.   
  1354.                   ELSE
  1355.                         BEGIN 
  1356.                            IF Local_Echo THEN WRITE( Comm_Ch );
  1357.                            Async_Send( Comm_Ch );
  1358.                         END;
  1359.  
  1360.                END (* CASE ORD( Comm_Ch ) *); 
  1361.   
  1362.             END (* KeyPressed *);
  1363.   
  1364.          IF ( Script_File_Mode AND ( NOT ( Done OR Really_Wait_String ) ) ) THEN
  1365.             BEGIN
  1366.                Get_Script_Command( PibTerm_Command );
  1367.                Execute_Command   ( PibTerm_Command , Done , TRUE );
  1368.             END;
  1369.   
  1370.          IF Async_Receive( Comm_Ch ) THEN
  1371.   
  1372.             BEGIN  (* Comm_Ch found *)
  1373.   
  1374.                Async_Buffer_Full;
  1375.   
  1376.                Comm_Ch := TrTab[ Comm_Ch ];
  1377.   
  1378.                IF Comm_Ch = CHR( ESC ) THEN
  1379.                   BEGIN (* ESC found *)
  1380.   
  1381.                      IF Escape_Mode THEN Ansi_Write_Escape; 
  1382.  
  1383.                      Escape_Str         := '';
  1384.                      Escape_Number      := 1;
  1385.                      Escape_Register[1] := 0;
  1386.                      Escape_Mode        := TRUE;
  1387.                      Escape_Type        := ' ';
  1388.   
  1389.                   END
  1390.   
  1391.                ELSE IF Escape_Mode THEN
  1392.   
  1393.                   CASE VT100_Allowed OF
  1394.                      TRUE:   VT100_Process_Escape( Comm_Ch );
  1395.                      FALSE:  Ansi_Process_Escape( Comm_Ch ); 
  1396.                   END (* CASE *)
  1397.   
  1398.                ELSE 
  1399.   
  1400.                   CASE ORD( Comm_Ch ) OF
  1401.   
  1402.                      LF,
  1403.                      FF,
  1404.                      VT:   BEGIN (* go down one line *) 
  1405.  
  1406.                               IF ( WhereY = Bottom_Scroll ) THEN
  1407.                                  BEGIN
  1408.                                     Window( 1, Top_Scroll, 80, Bottom_Scroll );
  1409.                                     Display_Character( CHR( LF ) );
  1410.                                     IF ( NOT Origin_Mode ) THEN
  1411.                                        Window( 1, 1, 80, 25 );
  1412.                                  END
  1413.                               ELSE
  1414.                                  Display_Character( CHR( LF ) );
  1415.   
  1416.                               IF Auto_Print_Mode THEN
  1417.                                  BEGIN
  1418.                                     Get_Screen_Text_Line( Print_Line, WhereY - 1,
  1419.                                                           1 );
  1420.                                     WRITELN( Lst , Print_Line );
  1421.                                  END;
  1422.   
  1423.                            END   (* go down one line *); 
  1424.   
  1425.                      HT:   BEGIN (* Convert tabs to sequence of blanks *)
  1426. (*
  1427.                               Curcol := WhereX;
  1428.                               Itab   := 1;
  1429.                               WHILE( Curcol > VT100_Tabs[Itab] ) DO
  1430.                                  Itab := Itab + 1;
  1431.                               Tabcol := VT100_Tabs[Itab]; 
  1432.                               FOR Itab := Curcol To ( Tabcol - 1 ) DO
  1433.                                  WRITE(' ');
  1434. *)
  1435.                               Display_Character( Comm_Ch );
  1436.                            END   (* Tabs *);
  1437.  
  1438.                      SO:   IF VT100_Allowed THEN
  1439.                               VT100_Graphics_Mode := ON;
  1440.   
  1441.                      SI:   IF VT100_Allowed THEN
  1442.                               VT100_Graphics_Mode := OFF;
  1443.   
  1444.                                    (* CompuServe B protocol request *)
  1445.   
  1446.                      ENQ:  IF CompuServe_B_On THEN
  1447.                               B := Do_CompuServe_B_Transfer
  1448.                            ELSE
  1449.                               Display_Character( Comm_Ch );
  1450.   
  1451.                      ELSE
  1452.                         IF NOT VT100_Graphics_Mode THEN
  1453.                            Display_Character( Comm_Ch )
  1454.                         ELSE
  1455.                            BEGIN (* Graphics Mode *)
  1456.                               IF ORD( Comm_Ch ) IN [ 95 .. 126 ] THEN
  1457.                                  BEGIN
  1458.                                     Graph_Ch := Graphics_Chars[ ORD( Comm_Ch ) ];
  1459.                                     Display_Character( CHR( Graph_Ch ) );
  1460.                                  END
  1461.                               ELSE
  1462.                                  Display_Character( Comm_Ch );
  1463.                            END   (* Graphics Mode *);
  1464.   
  1465.                   END (* CASE ORD( Comm_Ch ) *);
  1466.   
  1467.             END (* Comm_Ch found *)
  1468.                                    (* Check if waitstring time exhausted *)
  1469.          ELSE
  1470.             IF Really_Wait_String THEN
  1471.                Check_Wait_String_Time;
  1472.   
  1473.       END  (* NOT Done *); 
  1474.                                    (* Restore colors *)
  1475.   
  1476.    ForeGround_Color        := Save_FG;
  1477.    BackGround_Color        := Save_BG;
  1478.   
  1479.    Set_Global_Colors( ForeGround_Color , BackGround_Color );
  1480.   
  1481. END   (* Emulate_ANSI *);
  1482.   
  1483.